本文介绍了python3常用的数据结构。

字符串string

双引号””、单引号’’括起来都是字符串
访问字符串中元素：str[i]
数字转字符串：str()；字符串转数字：int()/float()
求字符串长度：len()
截取字符串：str[x:y]，前包后不包
字符->ASCII：ord('a'); ASCII->字符：chr(78)

转义字符

符号 意义
\n 换行符，另起一行
\r 将光标的位置回退到本行的开头位置，因此再输出就会覆盖之前的值
  • 注1：\r在VSCode的DEBUG CONCOLE下不起效果（不会覆盖之前的值），只在TERMINAL下起效果。
  • 注2：用\r可以实现很多有趣的小功能，如倒计时（每次用新string覆盖上一条string）、进度条等。

格式化字符串

百分号法

占位符 含义
%d 十进制整数
%f 浮点数，保留小数点后面六位
.3%f 浮点数，保留小数点后面三位
%e 浮点数，保留小数点后面六位有效数字，指数形式输出
%s 字符串

具体用法：
带占位符的字符串 + % + 要填充的内容（有多项的话用括号括起来，中间用逗号分割）

1
2
print('%d' % 20) # 输出20
s1 = "i am %s, i am %d years old" % ('jeck',26)    #按位置顺序依次输出

format法

  • 由花括号{}充当占位符
    1
    2
    3
    str1 = "I like {}".format("you") # "I like you"
    str2 = "I like {0} and {1}".format("running","swimming") # "I like running and swimming"
    str3 = "I like {} and {}".format("running","swimming") # 与str2等价，会自动按0,1,2的顺序向占位符中填充

列表list

即数组，但里面元素类型可不一致，lst=[‘a’,13,”lrrr”]
数组尾追加元素：lst.append，数组间插入元素：lst.insert(i,x)
删除数组元素：lst.pop(i)，返回值为删除的元素
将数组元素顺序颠倒：lst.reverse()
数组排序函数：lst.sort()
字符串->数组：split();数组->字符串：join()

List Comprehension机制

list comprehension是python中一种简洁的生成list的方式，可以在括号[]内部写生成的表达式，甚至可以加一些逻辑判断条件，用法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# create a new list with the values doubled
vec = [-4, -2, 0, 2, 4]
list1 = [x*2 for x in vec]  # [-8, -4, 0, 4, 8] 

# 加判断条件
list1 = [x for x in vec if x >= 0]  # [0, 2, 4]

# call a method on each element
freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
[weapon.strip() for weapon in freshfruit]
# 生成 ['banana', 'loganberry', 'passion fruit']

# 同样可以生成元组
[(x, x**2) for x in range(6)]

# 若有多个for语句则从左到右依次嵌套
# flatten a list using a listcomp with two 'for'
vec = [[1,2,3], [4,5,6], [7,8,9]]
# 生成 [1, 2, 3, 4, 5, 6, 7, 8, 9]

[num for elem in vec for num in elem]
[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
# 生成 [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
# 相当于
# for x in [1,2,3]:
#     for y in [3,1,4]:
#         if x != y:

元组tuple

元素值不可改变的list，遍历操作与list相同
初始化：t=(1,"ab",[123,"abc"]) 或 d=dict([("1","22"),("2","22")])用数组初始化
优点：遍历比列表快；对数据进行“写保护”；可在字典中用作key

字典dict

即哈希表，以键值对存储：dic={"n1":"ab","n2":"cd","n3":12}
键(key)不可修改，可以是字符串或元组；但键值可以更改。
通过键访问键值：dic[‘n1’]

如何根据value查key

1
2
3
for k, v in dictionary.items():    
    if v == search_avalue:
        print(k)

字典和JSON格式相互转化

1
2
3
4
5
6
7
8
9
10
11
12
13
import json

dict_obejct = { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 }
# 将dict对象转化为json字符串
dict_json = json.dumps(dict_obejct)
print(dict_json)
# {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
# 之后直接将字符串写到文件中里即可（最后记得加 \n）

# 从文件中读取的json字符串
json_str = "{\"a\": 1, \"b\": 2, \"c\": 3, \"d\": 4, \"e\": 5}"
dict_object = json.loads(json_str)
# JSON的object类型直接即转化为python的dict类型

JSON类型和Python类型转化(默认和dict相互转化)

JSON Python
object dict
array list/(tuple)
string str
number(int) int, long
number(real) float
true True
false False
null None

集合set

无序、不重复序列，s=set([123,'lrrr',"asd"])->s={'lrrr', 123, 'asd'}
集合增加元素：add；删除元素：remove
不可改变的集合：frozenset，集合一旦创建就不能再增加/删除元素。
可进行集合的“交并补”等运算，得到新的集合。

range类型

  • 用于产生一个有序序列，通常和for循环嵌套使用

range(a,b,t)：a为起点，b为终点，t为步长，是一个前开后闭的区间（包括起点不包括终点）
注：a默认0，t默认1。
range主要用于产生一个序列，在for in循环中很常见

1
2
3
x = range(10) #x是从0到9的一个range类型
for i in x:
    print(i) #循环输出0-9

range转List：list(range(1,10,3))

迭代器

iterator

所有实现了__next__()的类都可以作为迭代器（iterator）来使用，可以通过for循环进行遍历。

enumerte函数

enumerate(iterable, start=0)
作用：用于遍历iterator，且遍历的同时返回元素的下标。
输入：iterable：可迭代的对象(iterator)；start：下标从几开始。
输出：返回一个迭代器itertor，迭代对象为元组，包括index和所输入迭代器的迭代对象。

1
2
3
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
for (i, season) in enumerate(seasons):
    pass

zip函数

zip(*iterables)
作用：同时遍历几个iterators。
输入：需要同时遍历的iterators。
输出：返回一个迭代器ierator，迭代对象为元组，包括了各个输入的迭代器的迭代对象。

1
2
3
4
5
6
7
8
9
x = [1, 2, 3]
y = [4, 5, 6]
for (i,j) in zip(x, y):
    print("({0},{1})".format(i, j))\

# output
(1,4)
(2,5)
(3,6)

1
2
3
4
5
6
7
8
9
# zip函数使用举例
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True
  • generator
    和可迭代类型（Iterator）类似，区别：其不保存所有值，其只计算一个值，保存一个值，计算下一个值时这个值就会被覆盖。适用于数据只使用一次的场景。
    在函数中可使用yield语句来返回一个generator，类似return语句，但区别是在调用时其并没有真正计算值，只是返回了一个generator，等到真正访问generator时才会去一个一个地计算其值。

Post Date： 2019-03-06

版权声明： 本文为原创文章，转载请注明出处